/*--------------------------------------------------*/
/*VirtualSociety System ServiceModuleTemplate Class Body File*/
/*CreateBy SRPLab                */
/*CreateDate: 2011-3-29  */
/*--------------------------------------------------*/
#include "SRPSAGGLibEngine_VSClass.h"
ClassOfSAggPenClass::ClassOfSAggPenClass()
{
}

ClassOfSAggPenClass::ClassOfSAggPenClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggPenClass,0,NULL));
}

ClassOfSAggPenClass::ClassOfSAggPenClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggPenClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggPenClass" );
    return Buf;
}

class ClassOfSAggPenClass *ClassOfSAggPenClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggPenClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggPenClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggPenClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggPenClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_UINT8 ClassOfSAggPenClass::Get_Type()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> Type;
}
void ClassOfSAggPenClass::Put_Type(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_TYPE,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggPenClass::Get_SmoothType()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> SmoothType;
}
void ClassOfSAggPenClass::Put_SmoothType(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_SMOOTHTYPE,(VS_INT8 *)&In_Value);
}

VS_UINT16 ClassOfSAggPenClass::Get_Width()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> Width;
}
void ClassOfSAggPenClass::Put_Width(VS_UINT16 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_WIDTH,(VS_INT8 *)&In_Value);
}

VS_UUID ClassOfSAggPenClass::Get_TransForm()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> TransForm;
}
void ClassOfSAggPenClass::Put_TransForm(VS_UUID In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_TRANSFORM,(VS_INT8 *)&In_Value);
}

VS_COLOR ClassOfSAggPenClass::Get_Color()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> Color;
}
void ClassOfSAggPenClass::Put_Color(VS_COLOR In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_COLOR,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggPenClass::Get_Alpha()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> Alpha;
}
void ClassOfSAggPenClass::Put_Alpha(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_ALPHA,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggPenClass::Get_DashLen()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> DashLen;
}
void ClassOfSAggPenClass::Put_DashLen(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_DASHLEN,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggPenClass::Get_GapLen()
{
    return ((struct StructOfSAggPenClass *)ThisSRPObject) -> GapLen;
}
void ClassOfSAggPenClass::Put_GapLen(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGPENCLASS_GAPLEN,(VS_INT8 *)&In_Value);
}


void SRPAPI ClassOfSAggPenClass::C_Clear()
{
    SAggPenClass_C_ClearProc LocalProc;

    LocalProc = (SAggPenClass_C_ClearProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPenClass_C_Clear);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}

ClassOfSAggCanvasClass::ClassOfSAggCanvasClass()
{
}

ClassOfSAggCanvasClass::ClassOfSAggCanvasClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggCanvasClass,0,NULL));
}

ClassOfSAggCanvasClass::ClassOfSAggCanvasClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggCanvasClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggCanvasClass" );
    return Buf;
}

class ClassOfSAggCanvasClass *ClassOfSAggCanvasClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggCanvasClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggCanvasClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggCanvasClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggCanvasClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_UINT32 ClassOfSAggCanvasClass::Get_Width()
{
    return ((struct StructOfSAggCanvasClass *)ThisSRPObject) -> Width;
}
void ClassOfSAggCanvasClass::Put_Width(VS_UINT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCANVASCLASS_WIDTH,(VS_INT8 *)&In_Value);
}

VS_UINT32 ClassOfSAggCanvasClass::Get_Height()
{
    return ((struct StructOfSAggCanvasClass *)ThisSRPObject) -> Height;
}
void ClassOfSAggCanvasClass::Put_Height(VS_UINT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCANVASCLASS_HEIGHT,(VS_INT8 *)&In_Value);
}


void SRPAPI ClassOfSAggCanvasClass::C_Clear(VS_COLOR Color)
{
    SAggCanvasClass_C_ClearProc LocalProc;

    LocalProc = (SAggCanvasClass_C_ClearProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Clear);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,Color);
}
void SRPAPI ClassOfSAggCanvasClass::C_Rect1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_COLOR Color,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_Rect1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_Rect1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Rect1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,X2,Y2,Color,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_FillRect1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_COLOR Color,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_FillRect1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillRect1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillRect1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,X2,Y2,Color,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_OutLineRect1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_COLOR LineColor,VS_COLOR FillColor,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_OutLineRect1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_OutLineRect1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_OutLineRect1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,X2,Y2,LineColor,FillColor,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_Ellipse1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_COLOR Color,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_Ellipse1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_Ellipse1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Ellipse1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,Rx,Ry,Color,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_FillEllipse1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_COLOR Color,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_FillEllipse1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillEllipse1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillEllipse1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,Rx,Ry,Color,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_OutLineEllipse1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_COLOR LineColor,VS_COLOR FillColor,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_OutLineEllipse1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_OutLineEllipse1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_OutLineEllipse1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,Rx,Ry,LineColor,FillColor,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_Line1(VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_COLOR Color,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_Line1Proc LocalProc;

    LocalProc = (SAggCanvasClass_C_Line1Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Line1);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X1,Y1,X2,Y2,Color,Alpha);
}
void SRPAPI ClassOfSAggCanvasClass::C_DrawMarker(VS_INT32 Type,VS_INT32 X,VS_INT32 Y,VS_INT32 R,VS_COLOR LineColor,VS_COLOR FillColor,VS_UINT8 Alpha)
{
    SAggCanvasClass_C_DrawMarkerProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawMarkerProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawMarker);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,Type,X,Y,R,LineColor,FillColor,Alpha);
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_Ellipse(void *Pen,VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_INT32 Step,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_EllipseProc LocalProc;

    LocalProc = (SAggCanvasClass_C_EllipseProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Ellipse);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,X1,Y1,Rx,Ry,Step,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_FillEllipse(void *Brush,VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_INT32 Step,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_FillEllipseProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillEllipseProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillEllipse);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Brush,X1,Y1,Rx,Ry,Step,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_Arc(void *Pen,VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_FLOAT StartAngle,VS_FLOAT EndAngle,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_ArcProc LocalProc;

    LocalProc = (SAggCanvasClass_C_ArcProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Arc);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,X1,Y1,Rx,Ry,StartAngle,EndAngle,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_FillArc(void *Brush,VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_FLOAT StartAngle,VS_FLOAT EndAngle,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_FillArcProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillArcProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillArc);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Brush,X1,Y1,Rx,Ry,StartAngle,EndAngle,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_Line(void *Pen,VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_LineProc LocalProc;

    LocalProc = (SAggCanvasClass_C_LineProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Line);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,X1,Y1,X2,Y2,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_Rect(void *Pen,VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_RectProc LocalProc;

    LocalProc = (SAggCanvasClass_C_RectProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Rect);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,X1,Y1,X2,Y2,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_FillRect(void *Brush,VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_FillRectProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillRectProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillRect);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Brush,X1,Y1,X2,Y2,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_RoundRect(void *Pen,VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_FLOAT R,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_RoundRectProc LocalProc;

    LocalProc = (SAggCanvasClass_C_RoundRectProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_RoundRect);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,X1,Y1,X2,Y2,R,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_FillRoundRect(void *Brush,VS_INT32 X1,VS_INT32 Y1,VS_INT32 X2,VS_INT32 Y2,VS_FLOAT R,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_FillRoundRectProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillRoundRectProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillRoundRect);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Brush,X1,Y1,X2,Y2,R,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_Polygon(void *Pen,VS_INT32 Number,struct StructOfSAggPoint * Point,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_PolygonProc LocalProc;

    LocalProc = (SAggCanvasClass_C_PolygonProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_Polygon);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,Number,Point,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_FillPolygon(void *Brush,VS_INT32 Number,struct StructOfSAggPoint * Point,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_FillPolygonProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillPolygonProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillPolygon);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Brush,Number,Point,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawPath(void *Pen,void *Path,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_DrawPathProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawPathProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawPath);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Pen,Path,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawImage(VS_UINT8 SmoothType,VS_INT32 Left,VS_INT32 Top,VS_INT32 Right,VS_INT32 Bottom,void *ImageBuf,VS_INT32 ImgWidth,VS_INT32 ImgHeight,VS_INT32 SrcLeft,VS_INT32 SrcTop,VS_INT32 SrcRight,VS_INT32 SrcBottom,VS_BOOL EnableAlpha,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_DrawImageProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawImageProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawImage);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,SmoothType,Left,Top,Right,Bottom,ImageBuf,ImgWidth,ImgHeight,SrcLeft,SrcTop,SrcRight,SrcBottom,EnableAlpha,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawImageEx(VS_UINT8 SmoothType,struct StructOfSAggPoint * LeftTop,struct StructOfSAggPoint * RightTop,struct StructOfSAggPoint * RightBottom,struct StructOfSAggPoint * LeftBottom,void *ImgBuf,VS_INT32 ImgWidth,VS_INT32 ImgHeight,VS_INT32 SrcLeft,VS_INT32 SrcTop,VS_INT32 SrcRight,VS_INT32 SrcBottom,VS_BOOL EnableAlpha,VS_RECT * Bounds,VS_BOOL DrawFlag)
{
    SAggCanvasClass_C_DrawImageExProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawImageExProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawImageEx);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,SmoothType,LeftTop,RightTop,RightBottom,LeftBottom,ImgBuf,ImgWidth,ImgHeight,SrcLeft,SrcTop,SrcRight,SrcBottom,EnableAlpha,Bounds,DrawFlag);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawText(void *FontObject,VS_INT32 X,VS_INT32 Y,VS_FLOAT Angle,VS_COLOR Color,VS_UINT8 Alpha,VS_BOOL SolidFlag,VS_BOOL FlipY,VS_RECT * Bounds,VS_BOOL DrawFlag,VS_CHAR * Text)
{
    SAggCanvasClass_C_DrawTextProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawTextProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawText);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,FontObject,X,Y,Angle,Color,Alpha,SolidFlag,FlipY,Bounds,DrawFlag,Text);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawTextEx(void *FontObject,VS_INT32 X,VS_INT32 Y,VS_COLOR ColorStart,VS_UINT8 AlphaStart,VS_COLOR ColorEnd,VS_UINT8 AlphaEnd,VS_BOOL ColorTransX,VS_BOOL SolidFlag,VS_BOOL FlipY,VS_RECT * Bounds,VS_BOOL DrawFlag,VS_CHAR * Text)
{
    SAggCanvasClass_C_DrawTextExProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawTextExProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawTextEx);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,FontObject,X,Y,ColorStart,AlphaStart,ColorEnd,AlphaEnd,ColorTransX,SolidFlag,FlipY,Bounds,DrawFlag,Text);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawTextOnPath(void *FontObject,void *Path,void *TransForm,VS_UINT8 SmoothType,VS_COLOR Color,VS_UINT8 Alpha,VS_BOOL FlipY,VS_RECT * Bounds,VS_BOOL DrawFlag,VS_CHAR * Text)
{
    SAggCanvasClass_C_DrawTextOnPathProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawTextOnPathProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawTextOnPath);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,FontObject,Path,TransForm,SmoothType,Color,Alpha,FlipY,Bounds,DrawFlag,Text);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawTextOnArc(void *FontObject,VS_INT32 X1,VS_INT32 Y1,VS_INT32 Rx,VS_INT32 Ry,VS_FLOAT StartAngle,VS_FLOAT EndAngle,VS_BOOL Ccw,void *TransForm,VS_COLOR Color,VS_UINT8 Alpha,VS_BOOL FlipY,VS_RECT * Bounds,VS_BOOL DrawFlag,VS_CHAR * Text)
{
    SAggCanvasClass_C_DrawTextOnArcProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawTextOnArcProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawTextOnArc);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,FontObject,X1,Y1,Rx,Ry,StartAngle,EndAngle,Ccw,TransForm,Color,Alpha,FlipY,Bounds,DrawFlag,Text);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
VS_BOOL SRPAPI ClassOfSAggCanvasClass::C_DrawTextOnPolygon(void *FontObject,VS_INT32 Number,struct StructOfSAggPoint * Point,void *TransForm,VS_UINT8 SmoothType,VS_COLOR Color,VS_UINT8 Alpha,VS_BOOL FlipY,VS_RECT * Bounds,VS_BOOL DrawFlag,VS_CHAR * Text)
{
    SAggCanvasClass_C_DrawTextOnPolygonProc LocalProc;

    LocalProc = (SAggCanvasClass_C_DrawTextOnPolygonProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_DrawTextOnPolygon);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,FontObject,Number,Point,TransForm,SmoothType,Color,Alpha,FlipY,Bounds,DrawFlag,Text);
    else{
        VS_BOOL LocalReturnValue = VS_FALSE;

        return LocalReturnValue;
    }
}
void SRPAPI ClassOfSAggCanvasClass::C_FillBack()
{
    SAggCanvasClass_C_FillBackProc LocalProc;

    LocalProc = (SAggCanvasClass_C_FillBackProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_FillBack);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}
void *SRPAPI ClassOfSAggCanvasClass::C_GetImg(VS_UINT32 * Width,VS_UINT32 * Height)
{
    SAggCanvasClass_C_GetImgProc LocalProc;

    LocalProc = (SAggCanvasClass_C_GetImgProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggCanvasClass_C_GetImg);
    if( LocalProc != NULL )
        return LocalProc(ThisSRPObject,Width,Height);
    else{
        void *LocalReturnValue = NULL;

        return LocalReturnValue;
    }
}

ClassOfSAggPathClass::ClassOfSAggPathClass()
{
}

ClassOfSAggPathClass::ClassOfSAggPathClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggPathClass,0,NULL));
}

ClassOfSAggPathClass::ClassOfSAggPathClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggPathClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggPathClass" );
    return Buf;
}

class ClassOfSAggPathClass *ClassOfSAggPathClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggPathClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggPathClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggPathClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggPathClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

void SRPAPI ClassOfSAggPathClass::C_Clear()
{
    SAggPathClass_C_ClearProc LocalProc;

    LocalProc = (SAggPathClass_C_ClearProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_Clear);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}
void SRPAPI ClassOfSAggPathClass::C_MoveTo(VS_FLOAT X,VS_FLOAT Y)
{
    SAggPathClass_C_MoveToProc LocalProc;

    LocalProc = (SAggPathClass_C_MoveToProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_MoveTo);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X,Y);
}
void SRPAPI ClassOfSAggPathClass::C_LineTo(VS_FLOAT X,VS_FLOAT Y)
{
    SAggPathClass_C_LineToProc LocalProc;

    LocalProc = (SAggPathClass_C_LineToProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_LineTo);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X,Y);
}
void SRPAPI ClassOfSAggPathClass::C_ArcTo(VS_FLOAT Rx,VS_FLOAT Ry,VS_FLOAT Angle,VS_BOOL large_arc_flag,VS_BOOL sweep_flag,VS_FLOAT X,VS_FLOAT Y)
{
    SAggPathClass_C_ArcToProc LocalProc;

    LocalProc = (SAggPathClass_C_ArcToProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_ArcTo);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,Rx,Ry,Angle,large_arc_flag,sweep_flag,X,Y);
}
void SRPAPI ClassOfSAggPathClass::C_Curve3(VS_FLOAT CX,VS_FLOAT CY,VS_FLOAT X,VS_FLOAT Y)
{
    SAggPathClass_C_Curve3Proc LocalProc;

    LocalProc = (SAggPathClass_C_Curve3Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_Curve3);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,CX,CY,X,Y);
}
void SRPAPI ClassOfSAggPathClass::C_Curve4(VS_FLOAT CX1,VS_FLOAT CY1,VS_FLOAT CX2,VS_FLOAT CY2,VS_FLOAT X,VS_FLOAT Y)
{
    SAggPathClass_C_Curve4Proc LocalProc;

    LocalProc = (SAggPathClass_C_Curve4Proc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_Curve4);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,CX1,CY1,CX2,CY2,X,Y);
}
void SRPAPI ClassOfSAggPathClass::C_Close()
{
    SAggPathClass_C_CloseProc LocalProc;

    LocalProc = (SAggPathClass_C_CloseProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggPathClass_C_Close);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}

ClassOfSAggTransFormClass::ClassOfSAggTransFormClass()
{
}

ClassOfSAggTransFormClass::ClassOfSAggTransFormClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggTransFormClass,0,NULL));
}

ClassOfSAggTransFormClass::ClassOfSAggTransFormClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggTransFormClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggTransFormClass" );
    return Buf;
}

class ClassOfSAggTransFormClass *ClassOfSAggTransFormClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggTransFormClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggTransFormClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggTransFormClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggTransFormClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

void SRPAPI ClassOfSAggTransFormClass::C_Clear()
{
    SAggTransFormClass_C_ClearProc LocalProc;

    LocalProc = (SAggTransFormClass_C_ClearProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_Clear);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}
void SRPAPI ClassOfSAggTransFormClass::C_Translate(VS_FLOAT X,VS_FLOAT Y)
{
    SAggTransFormClass_C_TranslateProc LocalProc;

    LocalProc = (SAggTransFormClass_C_TranslateProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_Translate);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X,Y);
}
void SRPAPI ClassOfSAggTransFormClass::C_Rotate(VS_FLOAT Angle)
{
    SAggTransFormClass_C_RotateProc LocalProc;

    LocalProc = (SAggTransFormClass_C_RotateProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_Rotate);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,Angle);
}
void SRPAPI ClassOfSAggTransFormClass::C_Scale(VS_FLOAT X,VS_FLOAT Y)
{
    SAggTransFormClass_C_ScaleProc LocalProc;

    LocalProc = (SAggTransFormClass_C_ScaleProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_Scale);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,X,Y);
}
void SRPAPI ClassOfSAggTransFormClass::C_FlipX()
{
    SAggTransFormClass_C_FlipXProc LocalProc;

    LocalProc = (SAggTransFormClass_C_FlipXProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_FlipX);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}
void SRPAPI ClassOfSAggTransFormClass::C_FlipY()
{
    SAggTransFormClass_C_FlipYProc LocalProc;

    LocalProc = (SAggTransFormClass_C_FlipYProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggTransFormClass_C_FlipY);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}

ClassOfSAggFontClass::ClassOfSAggFontClass()
{
}

ClassOfSAggFontClass::ClassOfSAggFontClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggFontClass,0,NULL));
}

ClassOfSAggFontClass::ClassOfSAggFontClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggFontClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggFontClass" );
    return Buf;
}

class ClassOfSAggFontClass *ClassOfSAggFontClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggFontClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggFontClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggFontClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggFontClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_VSTRING ClassOfSAggFontClass::Get_FontName()
{
    return ((struct StructOfSAggFontClass *)ThisSRPObject) -> FontName;
}
void ClassOfSAggFontClass::Put_FontName(VS_VSTRING In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGFONTCLASS_FONTNAME,(VS_INT8 *)In_Value.Buf);
}

VS_INT32 ClassOfSAggFontClass::Get_Height()
{
    return ((struct StructOfSAggFontClass *)ThisSRPObject) -> Height;
}
void ClassOfSAggFontClass::Put_Height(VS_INT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGFONTCLASS_HEIGHT,(VS_INT8 *)&In_Value);
}

VS_BOOL ClassOfSAggFontClass::Get_Italic()
{
    return ((struct StructOfSAggFontClass *)ThisSRPObject) -> Italic;
}
void ClassOfSAggFontClass::Put_Italic(VS_BOOL In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGFONTCLASS_ITALIC,(VS_INT8 *)&In_Value);
}

VS_BOOL ClassOfSAggFontClass::Get_Hinting()
{
    return ((struct StructOfSAggFontClass *)ThisSRPObject) -> Hinting;
}
void ClassOfSAggFontClass::Put_Hinting(VS_BOOL In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGFONTCLASS_HINTING,(VS_INT8 *)&In_Value);
}



ClassOfSAggBrushClass::ClassOfSAggBrushClass()
{
}

ClassOfSAggBrushClass::ClassOfSAggBrushClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggBrushClass,0,NULL));
}

ClassOfSAggBrushClass::ClassOfSAggBrushClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggBrushClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggBrushClass" );
    return Buf;
}

class ClassOfSAggBrushClass *ClassOfSAggBrushClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggBrushClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggBrushClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggBrushClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggBrushClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_UINT8 ClassOfSAggBrushClass::Get_Type()
{
    return ((struct StructOfSAggBrushClass *)ThisSRPObject) -> Type;
}
void ClassOfSAggBrushClass::Put_Type(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGBRUSHCLASS_TYPE,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggBrushClass::Get_SmoothType()
{
    return ((struct StructOfSAggBrushClass *)ThisSRPObject) -> SmoothType;
}
void ClassOfSAggBrushClass::Put_SmoothType(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGBRUSHCLASS_SMOOTHTYPE,(VS_INT8 *)&In_Value);
}

VS_UUID ClassOfSAggBrushClass::Get_TransForm()
{
    return ((struct StructOfSAggBrushClass *)ThisSRPObject) -> TransForm;
}
void ClassOfSAggBrushClass::Put_TransForm(VS_UUID In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGBRUSHCLASS_TRANSFORM,(VS_INT8 *)&In_Value);
}

void ClassOfSAggBrushClass::Put_F_C_Clear(void * In_Value)
{
    ThisSRPInterface -> CreateOVLFunction(ThisSRPObject,&VSFUNCID_SAggBrushClass_C_Clear,In_Value,NULL);
}
void * ClassOfSAggBrushClass::Get_F_C_Clear()
{
    return NULL;
}


void SRPAPI ClassOfSAggBrushClass::C_Clear()
{
    SAggBrushClass_C_ClearProc LocalProc;

    LocalProc = (SAggBrushClass_C_ClearProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggBrushClass_C_Clear);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject);
}

ClassOfSAggColorSpanBrushClass::ClassOfSAggColorSpanBrushClass()
{
}

ClassOfSAggColorSpanBrushClass::ClassOfSAggColorSpanBrushClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggColorSpanBrushClass,0,NULL));
}

ClassOfSAggColorSpanBrushClass::ClassOfSAggColorSpanBrushClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggColorSpanBrushClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggColorSpanBrushClass" );
    return Buf;
}

class ClassOfSAggColorSpanBrushClass *ClassOfSAggColorSpanBrushClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggColorSpanBrushClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggColorSpanBrushClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggColorSpanBrushClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggColorSpanBrushClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_UINT8 ClassOfSAggColorSpanBrushClass::Get_GradientType()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientType;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientType(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTTYPE,(VS_INT8 *)&In_Value);
}

VS_VSTRING ClassOfSAggColorSpanBrushClass::Get_Color()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> Color;
}
void ClassOfSAggColorSpanBrushClass::Put_Color(VS_VSTRING In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_COLOR,(VS_INT8 *)In_Value.Buf);
}

VS_INT32 ClassOfSAggColorSpanBrushClass::Get_StartPosX()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> StartPosX;
}
void ClassOfSAggColorSpanBrushClass::Put_StartPosX(VS_INT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_STARTPOSX,(VS_INT8 *)&In_Value);
}

VS_INT32 ClassOfSAggColorSpanBrushClass::Get_StartPosY()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> StartPosY;
}
void ClassOfSAggColorSpanBrushClass::Put_StartPosY(VS_INT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_STARTPOSY,(VS_INT8 *)&In_Value);
}

VS_INT32 ClassOfSAggColorSpanBrushClass::Get_GradientStart()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientStart;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientStart(VS_INT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTSTART,(VS_INT8 *)&In_Value);
}

VS_INT32 ClassOfSAggColorSpanBrushClass::Get_GradientEnd()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientEnd;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientEnd(VS_INT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTEND,(VS_INT8 *)&In_Value);
}

VS_FLOAT ClassOfSAggColorSpanBrushClass::Get_GradientR()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientR;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientR(VS_FLOAT In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTR,(VS_INT8 *)&In_Value);
}

VS_FLOAT ClassOfSAggColorSpanBrushClass::Get_GradientFx()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientFx;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientFx(VS_FLOAT In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTFX,(VS_INT8 *)&In_Value);
}

VS_FLOAT ClassOfSAggColorSpanBrushClass::Get_GradientFy()
{
    return ((struct StructOfSAggColorSpanBrushClass *)ThisSRPObject) -> GradientFy;
}
void ClassOfSAggColorSpanBrushClass::Put_GradientFy(VS_FLOAT In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORSPANBRUSHCLASS_GRADIENTFY,(VS_INT8 *)&In_Value);
}



ClassOfSAggImgBrushClass::ClassOfSAggImgBrushClass()
{
}

ClassOfSAggImgBrushClass::ClassOfSAggImgBrushClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggImgBrushClass,0,NULL));
}

ClassOfSAggImgBrushClass::ClassOfSAggImgBrushClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggImgBrushClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggImgBrushClass" );
    return Buf;
}

class ClassOfSAggImgBrushClass *ClassOfSAggImgBrushClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggImgBrushClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggImgBrushClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggImgBrushClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggImgBrushClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_UINT32 ClassOfSAggImgBrushClass::Get_ImgWidth()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> ImgWidth;
}
void ClassOfSAggImgBrushClass::Put_ImgWidth(VS_UINT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_IMGWIDTH,(VS_INT8 *)&In_Value);
}

VS_UINT32 ClassOfSAggImgBrushClass::Get_ImgHeight()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> ImgHeight;
}
void ClassOfSAggImgBrushClass::Put_ImgHeight(VS_UINT32 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_IMGHEIGHT,(VS_INT8 *)&In_Value);
}

void * ClassOfSAggImgBrushClass::Get_ImgBuf()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> ImgBuf;
}
void ClassOfSAggImgBrushClass::Put_ImgBuf(void * In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_IMGBUF,(VS_INT8 *)In_Value);
}

VS_UUID ClassOfSAggImgBrushClass::Get_ImgTransForm()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> ImgTransForm;
}
void ClassOfSAggImgBrushClass::Put_ImgTransForm(VS_UUID In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_IMGTRANSFORM,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggImgBrushClass::Get_ImgAccessType()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> ImgAccessType;
}
void ClassOfSAggImgBrushClass::Put_ImgAccessType(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_IMGACCESSTYPE,(VS_INT8 *)&In_Value);
}

VS_BOOL ClassOfSAggImgBrushClass::Get_EnableAlpha()
{
    return ((struct StructOfSAggImgBrushClass *)ThisSRPObject) -> EnableAlpha;
}
void ClassOfSAggImgBrushClass::Put_EnableAlpha(VS_BOOL In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGIMGBRUSHCLASS_ENABLEALPHA,(VS_INT8 *)&In_Value);
}


void SRPAPI ClassOfSAggImgBrushClass::C_SetImg(VS_UINT32 Width,VS_UINT32 Height,void *ImgBuf)
{
    SAggImgBrushClass_C_SetImgProc LocalProc;

    LocalProc = (SAggImgBrushClass_C_SetImgProc)ThisSRPInterface -> GetFunctionEx(ThisSRPObject,&VSFUNCID_SAggImgBrushClass_C_SetImg);
    if( LocalProc != NULL )
        LocalProc(ThisSRPObject,Width,Height,ImgBuf);
}

ClassOfSAggColorBrushClass::ClassOfSAggColorBrushClass()
{
}

ClassOfSAggColorBrushClass::ClassOfSAggColorBrushClass(class ClassOfSRPInterface *In_SRPInterface)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_TRUE,VS_FALSE,In_SRPInterface -> MallocObjectL(&VSOBJID_SAggColorBrushClass,0,NULL));
}

ClassOfSAggColorBrushClass::ClassOfSAggColorBrushClass(class ClassOfSRPInterface *In_SRPInterface,void *SRPObject)
{
    if( In_SRPInterface == NULL )
        return;
    WrapObject(In_SRPInterface,VS_FALSE,VS_FALSE,SRPObject);
}

VS_CHAR *ClassOfSAggColorBrushClass::GetSelfName()
{
    static VS_CHAR Buf[64];
    strcpy( Buf, "SAggColorBrushClass" );
    return Buf;
}

class ClassOfSAggColorBrushClass *ClassOfSAggColorBrushClass::GetSRPWrap( class ClassOfSRPInterface *In_SRPInterface,void *SRPObject,VS_ULONG In_ClassLayer)
{
    class ClassOfSAggColorBrushClass *ClassObject;

    if( SRPObject == NULL || In_SRPInterface == NULL )
        return NULL;
    if( In_ClassLayer == 0xFFFFFFFF )
        In_ClassLayer = In_SRPInterface -> GetLayer( SRPObject );
    ClassObject = (class ClassOfSAggColorBrushClass *)In_SRPInterface -> GetAppClass( SRPObject, In_ClassLayer );
    if( ClassObject != NULL && strcmp( ((class ClassOfSRPObject *)ClassObject) -> GetSelfName(), "SAggColorBrushClass" ) == 0 )
        return ClassObject;
    ClassObject = new class ClassOfSAggColorBrushClass();
    ClassObject -> WrapObject(In_SRPInterface,VS_FALSE,VS_TRUE,SRPObject, In_ClassLayer);
    return ClassObject;
}

VS_COLOR ClassOfSAggColorBrushClass::Get_Color()
{
    return ((struct StructOfSAggColorBrushClass *)ThisSRPObject) -> Color;
}
void ClassOfSAggColorBrushClass::Put_Color(VS_COLOR In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORBRUSHCLASS_COLOR,(VS_INT8 *)&In_Value);
}

VS_UINT8 ClassOfSAggColorBrushClass::Get_Alpha()
{
    return ((struct StructOfSAggColorBrushClass *)ThisSRPObject) -> Alpha;
}
void ClassOfSAggColorBrushClass::Put_Alpha(VS_UINT8 In_Value)
{
    ThisSRPInterface -> ChangeObject(ThisSRPObject,VSATTRINDEX_SAGGCOLORBRUSHCLASS_ALPHA,(VS_INT8 *)&In_Value);
}



/*--------------------------------------------------*/
